1， es5 类 和 es6 类
   类声明 和 函数声明的区别 和 特点
	。函数声明可以被提示，类声明不能提示
	。类声明的代码自动 强行运行在严格模式下
	。某一个类都有一个 constructor 的方法
	。只能使用 new 来调用类的 构造函数
	。不能在 类中 修改类名
2，类的表达式 有 2种形式 
	。声明式
	。表达式
3，类构造函数 立即调用，创造单例	
4，类中的 函数名 可以是 变量
5，静态成员 static 
	特点：在属性名 或 属性名上 加上 static关键字，
		 和普通方法不一样的是，static修饰的方法 不能在实例中访问，
		 只能在类中直接访问
6，”派生类“ 是什么？
	。派生类：是指继承自其它类的新类
7，super 使用的几点要求
	。只可以在 ”派生类“ 使用 super 
	。在构造函数中 ，访问this之前要 调用 super(), 因为super 初始化了this

1， <br/>
	es5 类
	<script>
		function Person(name) {
            this.name = name;
		}
		Person.prototype.sayName = function() {
			return this.name
		}
		var p = new Person('zhang')
		console.log('p.sayName', p.sayName())   // zhang
	</script>
    es6 类
    <script>
    	class Person2 {
    		// 新建构造函数
    		constructor(name) {
    			this.name = name // 私有属性
    		}
            // 定义一个方法 并且赋值给构造函数 的原型
            sayName2() {
            	return this.name
            }
    	}
    	let p2 = new Person2('zhang2')
    	console.log('p2.sayName2', p2.sayName2()) // zhang2
    </script>
2， <br/>
	类的表达式
	第一种： 声明式
	<script>
		class B {
			constructor() {}
		}
	</script>
	第二种： 匿名式
	<script>
		//匿名式 表达式
		let C = class {
			constructor() {}
		}
		// 命名表达式， D可以在外部使用，而E 只能在内部使用
		let D = class E {
			constructor() {}
		}
	</script>
3， <br/>
	类构造函数 立即调用，创造单例
	<script>
		let F = new class {
			constructor( name ) {
                this.name = name
			}
			sayName() {
				return this.name
			}
		}('zhang3')
        console.log( F.sayName() ) // zhang3
	</script>
4， <br/>
	类中的 函数名 可以是 变量
	<script>
		let m = 'sayName'
		class G {
			constructor(name) {
				this.name = name
			}
			[m]() {
				return this.name
			}
		}
		let g = new G('zhang4')
		console.log( g.sayName() )  // zhang4
	</script>
5， <br/>
	静态成员 static 
	<script>
		class H {
			static create() {
				console.log('static_create')
			}
		}
		H.create()

		//这个 实例的方式访问 访问不到
		var h = new H()
		// h.create() // h.create is not a function
	</script>
6， <br/>
	A叫做 “派生类”
	<script>
		// class A extends Component {

		// }
	</script>
7， <br/>
	在构造函数中 ，访问this之前要 调用 super(), 因为super 初始化了this
	<script>
		// class T extends Component {
		// 	constructor(props) {
		// 		this.name = 1  // 错误， 必须先写 super()
		// 		super(props)
		// 	}
		// }
	</script>






























